ETO Development Tools 4/ETO Development Tools 4.iso/Tools - Objects/MacApp/MacApp 3.0a2/Libraries/UInspector.inc1.p

Text File | 1991-05-01 | 69.2 KB | 2,621 lines | [TEXT/MPS ]

{$P}
{[a-,body+,h-,o=100,r+,rec+,t=4,u+,#+,j=20/57/1$,n-]}
{UInspector.inc1.p}
{Copyright © 1987-1990 by Apple Computer, Inc.    All rights reserved.}

USES
    {
    • List units defining any constants, types or classes that are required for your implementation
    section (e.g. Packages or Errors)
    • Also list units defining the classes that you declared EXTERNAL in the interface section
    or wish to use in the implementation section.
    • Also list the units required by the interfaces of the above units.
    }
     AppleEvents, UEvent, UCommand, UEvtHandler, UList, Editions, Dialogs, UApplication, UDocument,
     Balloons, UViewServer, UAdorners, UView,  UWindow, UScroller, UFailure, UMacAppUniversal, UMacAppUtilities,
     Menus, UMenuMgr, UPatch, UMacAppGlobals, Resources, ToolUtils, Packages, Errors, UGeometry, UDebug, Fonts;

{$IFC NOT qDebugTheDebugger}
{$W+}
{$R-}
{$Init-}
{$OV-}
{$ENDC}
{$IFC qNames}
{$D+}
{$ENDC}

        CONST
            kInspectorWindowType = 900;
            bInternalString     = - 500;                { used to id strings used internal to
                                                         inspector }

TYPE
            TInspectWindow        = OBJECT; FORWARD;
            TObjListView        = OBJECT; FORWARD;
            TObjectView         = OBJECT; FORWARD;
            TClassListView        = OBJECT; FORWARD;

            TClassesByID        = OBJECT (TSortedList)

                PROCEDURE TClassesByID.IClassesByID;

                FUNCTION TClassesByID.Compare(item1, item2: TObject): INTEGER; OVERRIDE;

                PROCEDURE TClassesByID.Fields(obj: TObject); OVERRIDE;

                END;

            TClassesByName        = OBJECT (TSortedList)

                PROCEDURE TClassesByName.IClassesByName;

                FUNCTION TClassesByName.Compare(item1, item2: TObject): INTEGER; OVERRIDE;

                PROCEDURE TClassesByName.Fields(obj: TObject); OVERRIDE;

                END;

            TInspector            = OBJECT (TDocument)

                fClassesByID:        TClassesByID;
                fClassesByName:     TClassesByName;
                fWindowCount:        INTEGER;
                fStaggerCount:        INTEGER;

                PROCEDURE TInspector.Initialize; OVERRIDE;
                { Puts a newly created TInspector into a known state. Subclasses should
                override it and call INHERITED. Typically used to put the object into a state where
                it can be safely FREED. }

                PROCEDURE TInspector.IInspector;

                PROCEDURE TInspector.Free; OVERRIDE;

                FUNCTION TInspector.MakeWindow: TInspectWindow;

                FUNCTION TInspector.AddObjectList(classId: ObjClassID): TSortedList;

                FUNCTION TInspector.GetObjectList(classId: ObjClassID): TSortedList;

                PROCEDURE TInspector.AddObject(theObject: TObject);

                PROCEDURE TInspector.RemoveObject(theObject: TObject);

                PROCEDURE TInspector.DoSetupMenus; OVERRIDE;

                PROCEDURE TInspector.Fields(obj: TObject); OVERRIDE;

                END;

            TInspectWindow        = OBJECT (TWindow)

                fClassListView:     TClassListView;
                fObjListView:        TObjListView;
                fObjectView:        TObjectView;

                PROCEDURE TInspectWindow.Initialize; OVERRIDE;
                { Puts a newly created TInspectWindow into a known state. Subclasses should
                override it and call INHERITED. Typically used to put the object into a state where
                it can be safely FREED. }

                PROCEDURE TInspectWindow.IRes(itsDocument: TDocument;
                                              itsSuperView: TView;
                                              VAR itsParams: Ptr); OVERRIDE;
                PROCEDURE TInspectWindow.IInspectWindow;

                PROCEDURE TInspectWindow.Draw(area: VRect); OVERRIDE;

                PROCEDURE TInspectWindow.CloseByUser; OVERRIDE;

                PROCEDURE TInspectWindow.InsertClass(itemNo: INTEGER);

                PROCEDURE TInspectWindow.Resize(newSize: VPoint;
                                             invalidate: BOOLEAN); OVERRIDE;

                PROCEDURE TInspectWindow.SetNumberOfClasses(noOfClasses: INTEGER);

                PROCEDURE TInspectWindow.SetTitleForDoc(newDocTitle: Str255); OVERRIDE;

                PROCEDURE TInspectWindow.SelectObject(theObject: TObject;
                                                      theType: INTEGER);

                PROCEDURE TInspectWindow.Fields(obj: TObject); OVERRIDE;

                END;

            TListView            = OBJECT (TView)

                fCurrentSelection:    INTEGER;            { index of the current selection, if any,
                                                         otherwise 0 }
                fNumberOfItems:     INTEGER;            { number of items currently in the list }
                fTextStyle:         TextStyle;            { font characteristics }
                fItemHeight:        INTEGER;            { height of each item including leading }
                fLineAscent:        INTEGER;            { position of baseline relative to top of
                                                         line }

                PROCEDURE TListView.Initialize; OVERRIDE;

                PROCEDURE TListView.IRes(itsDocument: TDocument;
                                         itsSuperView: TView;
                                         VAR itsParams: Ptr); OVERRIDE;
                PROCEDURE TListView.IListView(itsDocument: TDocument;
                                              itsSuperView: TView;
                                              itsLocation: VPoint;
                                              itsSize: VPoint;
                                              itsTextStyle: TextStyle;
                                              itsNumberOfItems: INTEGER;
                                              itsHSizeDet: SizeDeterminer);

                PROCEDURE TListView.CalcMinSize(VAR minSize: VPoint); OVERRIDE;

                PROCEDURE TListView.ChangeSelection(index: INTEGER;
                                                    highlight: BOOLEAN);

                PROCEDURE TListView.DoHighlightSelection(fromHL, toHL: HLState); OVERRIDE;

                PROCEDURE TListView.DoMouseCommand(VAR theMouse: VPoint;
                                                   event: TToolboxEvent;
                                                   hysteresis: Point); OVERRIDE;

                PROCEDURE TListView.Draw(area: VRect); OVERRIDE;

                PROCEDURE TListView.DrawItem(itemNumber: INTEGER;
                                             basePoint: VPoint);

                PROCEDURE TListView.Fields(obj: TObject); OVERRIDE;

                PROCEDURE TListView.InsertItem(itemNo: INTEGER);

                PROCEDURE TListView.DeleteItem(itemNo: INTEGER);

                PROCEDURE TListView.ItemToVRect(index: INTEGER;
                                                VAR itemRect: VRect);

                PROCEDURE TListView.RevealItem(itemNumber: INTEGER);

                PROCEDURE TListView.SelectItem(itemNumber: INTEGER);

                PROCEDURE TListView.SetStyle(itsTextStyle: TextStyle);

                PROCEDURE TListView.SetNumberOfItems(numberOfItems: INTEGER);

                PROCEDURE TListView.SetPen;

                FUNCTION TListView.VPointToItem(thePoint: VPoint): INTEGER;

                END;

            TClassListView        = OBJECT (TListView)    {Upper-left view}

                fInspectWindow:     TInspectWindow;

                PROCEDURE TClassListView.Initialize; OVERRIDE;

                PROCEDURE TClassListView.IRes(itsDocument: TDocument;
                                              itsSuperView: TView;
                                              VAR itsParams: Ptr); OVERRIDE;

                PROCEDURE TClassListView.IClassListView(itsWindow: TInspectWindow;
                                                        itsLocation: VPoint;
                                                        itsSize: VPoint);

                PROCEDURE TClassListView.DrawItem(itemNumber: INTEGER;
                                                  basePoint: VPoint); OVERRIDE;

                PROCEDURE TClassListView.SelectItem(itemNumber: INTEGER); OVERRIDE;

                PROCEDURE TClassListView.Fields(obj: TObject); OVERRIDE;

                END;

            TObjListView        = OBJECT (TListView)    {Upper-right view}

                fInspectWindow:     TInspectWindow;
                fObjectList:        TSortedList;

                PROCEDURE TObjListView.Initialize; OVERRIDE;

                PROCEDURE TObjListView.IRes(itsDocument: TDocument;
                                            itsSuperView: TView;
                                            VAR itsParams: Ptr); OVERRIDE;

                PROCEDURE TObjListView.IObjListView(itsWindow: TInspectWindow;
                                                    itsLocation: VPoint;
                                                    itsSize: VPoint);

                PROCEDURE TObjListView.InstallObjectList(theObjectList: TSortedList);

                PROCEDURE TObjListView.DrawItem(itemNumber: INTEGER;
                                                basePoint: VPoint); OVERRIDE;

                PROCEDURE TObjListView.SelectItem(itemNumber: INTEGER); OVERRIDE;

                PROCEDURE TObjListView.Fields(obj: TObject); OVERRIDE;

                END;

            TObjectView         = OBJECT (TListView)    {bottom view}

                fInspectWindow:     TInspectWindow;
                fObject:            TObject;
                fType:                INTEGER;
                fLockState:         BOOLEAN;
                fFieldsStaticLink:    Ptr;
                fFieldsProc:        ProcPtr;

                PROCEDURE TObjectView.Initialize; OVERRIDE;

                PROCEDURE TObjectView.IRes(itsDocument: TDocument;
                                           itsSuperView: TView;
                                           VAR itsParams: Ptr); OVERRIDE;

                PROCEDURE TObjectView.IObjectView(itsWindow: TInspectWindow;
                                                  itsLocation: VPoint;
                                                  itsSize: VPoint);

                PROCEDURE TObjectView.InspectControlHandle(PROCEDURE
                                                           InspectField(fieldName: StringPtr;
                                                                        fieldAddr: Ptr;
                                                                        fieldType: INTEGER));

                PROCEDURE TObjectView.InspectGrafPtr(PROCEDURE
                                                     InspectField(fieldName: StringPtr;
                                                                  fieldAddr: Ptr;
                                                                  fieldType: INTEGER));

                PROCEDURE TObjectView.InspectRgnHandle(PROCEDURE
                                                       InspectField(fieldName: StringPtr;
                                                                    fieldAddr: Ptr;
                                                                    fieldType: INTEGER));

                PROCEDURE TObjectView.InspectTEHandle(PROCEDURE
                                                      InspectField(fieldName: StringPtr;
                                                                   fieldAddr: Ptr;
                                                                   fieldType: INTEGER));

                PROCEDURE TObjectView.InspectWindowPtr(PROCEDURE
                                                       InspectField(fieldName: StringPtr;
                                                                    fieldAddr: Ptr;
                                                                    fieldType: INTEGER));

                PROCEDURE TObjectView.InspectHandle(PROCEDURE
                                                    InspectField(fieldName: StringPtr;
                                                                 fieldAddr: Ptr;
                                                                 fieldType: INTEGER));

                PROCEDURE TObjectView.LockObject;

                PROCEDURE TObjectView.UnlockObject;

                PROCEDURE TObjectView.ChangeSelection(index: INTEGER;
                                                      highlight: BOOLEAN); OVERRIDE;

                PROCEDURE TObjectView.SelectField(index: INTEGER;
                                                  inspectWindow: TInspectWindow);

                PROCEDURE TObjectView.DoMouseCommand(VAR theMouse: VPoint;
                                                     event: TToolboxEvent;
                                                     hysteresis: Point); OVERRIDE;

                PROCEDURE TObjectView.Draw(area: VRect); OVERRIDE;

                PROCEDURE TObjectView.DrawItem(itemNumber: INTEGER;
                                               basePoint: VPoint); OVERRIDE;

                PROCEDURE TObjectView.SuperViewChangedSize(delta: VPoint;
                                                           invalidate: BOOLEAN); OVERRIDE;

                PROCEDURE TObjectView.Resize(newSize: VPoint;
                                             invalidate: BOOLEAN); OVERRIDE;

                PROCEDURE TObjectView.FirstFieldThat(FUNCTION
                                                     TestField(fieldName: StringPtr;
                                                               fieldAddr: Ptr;
                                                               fieldType: INTEGER): BOOLEAN);

                PROCEDURE TObjectView.InstallObject(theObject: TObject;
                                                    theObjectType: INTEGER);

                PROCEDURE TObjectView.Fields(obj: TObject); OVERRIDE;
                PROCEDURE TObjectView.DoToField(fieldName: StringPtr;
                                                fieldAddr: Ptr;
                                                fieldType: INTEGER); OVERRIDE;

                END;



VAR
{$Push} {$Z+}                                            { Make the root of the inspector visible to
                                                         selected friends }
    pInspector:         TInspector;
{$Pop}
    pInspectorStyle:    TextStyle;
    pSavedFocus:        FocusRec;
    pAddNewObjectsToInspector: BOOLEAN;

{$IFC qTrace} {$D+} {$ENDC}                             { Turn off tracing for all Inspector code in
                                                         this file }
{$S MAInspector}                                        { Everything goes in here }

    {---------------------------------------------------------------------------}

{$Push}
{$IFC qTrace}
{$IFC qDebugTheDebugger}
{$D++}
{$ENDC}
{$ENDC}

PROCEDURE AddObjectToInspector(theObject: TObject);
 {This is called from %_OBNEW when an object is created, and from
  TObject.ShallowClone when cloning an object.}

    BEGIN
    IF pAddNewObjectsToInspector & (pInspector <> NIL) & (theObject <> NIL) THEN
        pInspector.AddObject(theObject);
    END;
{$Pop}

{--------------------------------------------------------------------------------------------------}

FUNCTION AddNewObjectsToInspector(add: BOOLEAN): BOOLEAN;

    BEGIN
    AddNewObjectsToInspector := pAddNewObjectsToInspector;
    pAddNewObjectsToInspector := add;
    END;

{---------------------------------------------------------------------------}

PROCEDURE InitUInspector;

    BEGIN
    IF qInspector THEN
        pAddNewObjectsToInspector := false;

    pInspector := NIL;
    SetTextStyle(pInspectorStyle, applFont, [], 9, gRGBBlack);
    pSavedFocus.itsViewPortInfo.clip := MakeNewRgn;

    IF qTemplateViews THEN
        BEGIN
        { Make sure linker doesn't dead strip these }
        IF gDeadStripSuppression THEN
            BEGIN
            IF Member(TObject(NIL), TInspectWindow) THEN;
            IF Member(TObject(NIL), TClassListView) THEN;
            IF Member(TObject(NIL), TObjListView) THEN;
            IF Member(TObject(NIL), TObjectView) THEN;
            END;
        END;

    IF qInspector THEN
        pAddNewObjectsToInspector := TRUE;

    END;

{---------------------------------------------------------------------------}

PROCEDURE MakeInspector;

    VAR
        anInspector:        TInspector;
        wasAddNewObjectsToInspector: BOOLEAN;
        wasTrcEnable:        BOOLEAN;

    BEGIN
{$IFC NOT qDebugTheDebugger}
{$IFC qDebug}
    wasTrcEnable := TrcEnable(False);
{$EndC}
    wasAddNewObjectsToInspector := AddNewObjectsToInspector(False);
{$ENDC}

    { Allocate and initialize the document}
    New(anInspector);
    anInspector.IInspector;

{$IFC NOT qDebugTheDebugger}
    IF AddNewObjectsToInspector(wasAddNewObjectsToInspector) THEN;
{$IFC qDebug}
    IF TrcEnable(wasTrcEnable) THEN;
{$EndC}
{$ENDC}
    END;

{---------------------------------------------------------------------------}

PROCEDURE MakeInspectorWindow;

    VAR
        wasAddNewObjectsToInspector: BOOLEAN;
        wasTrcEnable:        BOOLEAN;
        anInspectWindow:    TInspectWindow;

    BEGIN
{$IFC NOT qDebugTheDebugger}
{$IFC qDebug}
    wasTrcEnable := TrcEnable(False);
{$EndC}
    wasAddNewObjectsToInspector := AddNewObjectsToInspector(False);
{$ENDC}

    IF pInspector <> NIL THEN
        BEGIN
        anInspectWindow := pInspector.MakeWindow;
        anInspectWindow.Open;
        END;

{$IFC NOT qDebugTheDebugger}
    IF AddNewObjectsToInspector(wasAddNewObjectsToInspector) THEN;
{$IFC qDebug}
    IF TrcEnable(wasTrcEnable) THEN;
{$EndC}
{$ENDC}
    END;

{---------------------------------------------------------------------------}

{$Push}
{$IFC qTrace}
{$IFC qDebugTheDebugger}
{$D++}
{$ENDC}
{$ENDC}

PROCEDURE RemoveObjectFromInspector(theObject: TObject);
{Called from TObject.Free.}

    VAR
        wasAddNewObjectsToInspector: BOOLEAN;
        wasTrcEnable:        BOOLEAN;

    BEGIN
{$IFC NOT qDebugTheDebugger}
{$IFC qDebug}
    wasTrcEnable := TrcEnable(False);
{$EndC}
    wasAddNewObjectsToInspector := AddNewObjectsToInspector(False);
{$ENDC}
    IF NOT gApplication.fAppDone THEN
        IF (pInspector <> NIL) & (theObject <> NIL) THEN
            pInspector.RemoveObject(theObject);
{$IFC NOT qDebugTheDebugger}
    IF AddNewObjectsToInspector(wasAddNewObjectsToInspector) THEN;
{$IFC qDebug}
    IF TrcEnable(wasTrcEnable) THEN;
{$EndC}
{$ENDC}
    END;
{$Pop}

{---------------------------------------------------------------------------}

PROCEDURE TClassesByID.IClassesByID;

    BEGIN
    ISortedList;
    END;

{---------------------------------------------------------------------------}

FUNCTION TClassesByID.Compare(item1, item2: TObject): INTEGER; OVERRIDE;

    BEGIN
    IF TSortedList(item1).fObjClassId < TSortedList(item2).fObjClassId THEN
        Compare := kItem1LessThanItem2
    ELSE IF TSortedList(item1).fObjClassId > TSortedList(item2).fObjClassId THEN
        Compare := kItem1GreaterThanItem2
    ELSE
        Compare := kItem1EqualItem2;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TClassesByID.Fields(obj: TObject); OVERRIDE;

    BEGIN
    WITH obj DO
        BEGIN
        DoToField(AtStr('TClassesByID'), NIL, bClass);
        END;
    INHERITED Fields(obj);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TClassesByName.IClassesByName;

    BEGIN
    ISortedList;
    END;

{---------------------------------------------------------------------------}

FUNCTION TClassesByName.Compare(item1, item2: TObject): INTEGER; OVERRIDE;

    VAR
        string1, string2:    MAName;

    BEGIN
    GetClassNameFromID(TSortedList(item1).fObjClassId, string1);
    GetClassNameFromID(TSortedList(item2).fObjClassId, string2);
    IF string1 < string2 THEN
        Compare := kItem1LessThanItem2
    ELSE IF string1 > string2 THEN
        Compare := kItem1GreaterThanItem2
    ELSE
        Compare := kItem1EqualItem2;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TClassesByName.Fields(obj: TObject); OVERRIDE;

    BEGIN
    WITH obj DO
        BEGIN
        DoToField(AtStr('TClassesByName'), NIL, bClass);
        END;
    INHERITED Fields(obj);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TInspector.Initialize; OVERRIDE;

    BEGIN
    INHERITED Initialize;
    fClassesByID := NIL;
    fClassesByName := NIL;
    fStaggerCount := 0;
    fWindowCount := 0;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspector.IInspector;

    VAR
        aClassesByName:     TClassesByName;
        aClassesById:        TClassesByID;

    BEGIN
    IDocument;
    SetTitle('Inspector');

    New(aClassesByName);
    aClassesByName.IClassesByName;
    aClassesByName.SetEltType('TSortedList');
    fClassesByName := aClassesByName;

    New(aClassesById);
    aClassesById.IClassesByID;
    aClassesById.SetEltType('TSortedList');
    fClassesByID := aClassesById;

    pInspector := SELF;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspector.Free; OVERRIDE;

    BEGIN
    fClassesByID := TClassesByID(FreeListIfObject(fClassesByID));

    fClassesByName := TClassesByName(FreeIfObject(fClassesByName));

    pInspector := NIL;

    INHERITED Free;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspector.Fields(obj: TObject); OVERRIDE;

    BEGIN
    WITH obj DO
        BEGIN
        DoToField(AtStr('TInspector'), NIL, bClass);
        DoToField(AtStr('fClassesByID'), @fClassesByID, bObject);
        DoToField(AtStr('fClassesByName'), @fClassesByName, bObject);
        DoToField(AtStr('fWindowCount'), @fWindowCount, bInteger);
        DoToField(AtStr('fStaggerCount'), @fStaggerCount, bInteger);
        END;
    INHERITED Fields(obj);
    END;

{---------------------------------------------------------------------------}

FUNCTION TInspector.MakeWindow: TInspectWindow;

    VAR
        anInspectWindow:    TInspectWindow;
        staggerCount:        INTEGER;
        screenRect:         Rect;
        aVPt:                VPoint;

    BEGIN
    fWindowCount := fWindowCount + 1;

    IF qTemplateViews THEN
        BEGIN
        anInspectWindow := TInspectWindow(gViewServer.NewTemplateWindow(kInspectorWindowType, SELF));

        WITH anInspectWindow DO
            BEGIN

            fClassListView := TClassListView(FindSubView('IVW1'));
            fObjListView := TObjListView(FindSubView('IVW2'));
            fObjectView := TObjectView(FindSubView('IVW3'));

            fClassListView.fInspectWindow := anInspectWindow;
            fObjListView.fInspectWindow := anInspectWindow;
            fObjectView.fInspectWindow := anInspectWindow;

            { Use GetMaxIntersectedDevice to Locate our window. }
            IF GetMaxIntersectedDevice(screenRect) = NIL THEN;
            WITH screenRect DO
                BEGIN
                SetVPt(aVPt, right - fWMgrWindow^.portRect.right, top + fContRgnInset.v);
                Locate(aVPt, kDontInvalidate);

                {Adapt height of window to height of screen}
                SetVPt(aVPt, fWMgrWindow^.portRect.right, Max(252, bottom - 192));
                IF bottom > 342 THEN
                    Resize(aVPt, kDontInvalidate);

                END;
            END;
        END

    ELSE
        BEGIN
        New(anInspectWindow);
        anInspectWindow.IInspectWindow;
        anInspectWindow.ForceOnScreen;
        END;

    WITH anInspectWindow DO
        BEGIN
        staggerCount := fStaggerCount;
        SimpleStagger( - kStdStaggerAmount, kStdStaggerAmount, staggerCount);
        fStaggerCount := staggerCount;

        SetNumberOfClasses(fClassesByID.GetSize);

        { Installs print handler if client app is using printing }
        InstallIfPrintHandler(gPrintHandler, fObjectView);

        END;

    MakeWindow := anInspectWindow;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspector.AddObject(theObject: TObject);

    VAR
        classId:            ObjClassID;
        theObjectList:        TSortedList;

    PROCEDURE ResetObjListView(aWindow: TInspectWindow);

        VAR
            objListView:        TObjListView;

        BEGIN
        objListView := aWindow.fObjListView;
        IF objListView.fObjectList = theObjectList THEN
            objListView.InsertItem(objListView.fNumberOfItems + 1);
        END;

    BEGIN
    GetFocus(pSavedFocus);
    gPrinting := False;
    gDrawingPictScrap := False;
    gDrawingPictScrapView := NIL;
    classId := GetClassID(theObject);
    theObjectList := GetObjectList(classId);
    IF theObjectList = NIL THEN
        theObjectList := AddObjectList(classId);
    theObjectList.Insert(theObject);
    IF (fWindowList <> NIL) & (fWindowList.GetSize > 0) THEN
        BEGIN
        ForAllWindowsDo(ResetObjListView);
        END;
    SetFocus(pSavedFocus);
    END;

{---------------------------------------------------------------------------}

FUNCTION TInspector.AddObjectList(classId: ObjClassID): TSortedList;

    VAR
        anObjectList:        TSortedList;
        classListItemNo:    INTEGER;
        oldAddNewObjectsToInspector: BOOLEAN;

    PROCEDURE ResetClassListView(aWindow: TInspectWindow);

        BEGIN
        aWindow.InsertClass(classListItemNo);
        END;

    BEGIN
    oldAddNewObjectsToInspector := AddNewObjectsToInspector(FALSE);
    New(anObjectList);
    IF AddNewObjectsToInspector(oldAddNewObjectsToInspector) THEN;

    anObjectList.ISortedList;
    anObjectList.SetEltTypeID(classId);

    fClassesByID.Insert(anObjectList);
    fClassesByName.Insert(anObjectList);
    classListItemNo := fClassesByName.GetIdentityItemNo(anObjectList);
    ForAllWindowsDo(ResetClassListView);
    AddObjectList := anObjectList;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspector.DoSetupMenus; OVERRIDE;

    BEGIN
    INHERITED DoSetupMenus;

    Enable(cSaveAs, False);
    Enable(cSaveCopy, False);
    END;

{---------------------------------------------------------------------------}

FUNCTION TInspector.GetObjectList(classId: ObjClassID): TSortedList;

    FUNCTION TestClass(anObjectList: TSortedList): INTEGER;

        BEGIN
        IF classId < anObjectList.fObjClassId THEN
            TestClass := kItemGreaterThanCriteria
        ELSE IF classId > anObjectList.fObjClassId THEN
            TestClass := kItemLessThanCriteria
        ELSE
            TestClass := kItemEqualCriteria;
        END;

    BEGIN
    GetObjectList := TSortedList(fClassesByID.Search(TestClass));
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspector.RemoveObject(theObject: TObject);

    VAR
        theObjectList:        TSortedList;
        index:                INTEGER;

    PROCEDURE CheckWindow(theInspectWindow: TInspectWindow);

        BEGIN
        IF theInspectWindow.fObjectView.fObject = theObject THEN
            theInspectWindow.fObjectView.InstallObject(NIL, 0);
        IF theInspectWindow.fObjListView.fObjectList = theObjectList THEN
            theInspectWindow.fObjListView.DeleteItem(index);
        END;

    BEGIN
    IF (fClassesByID <> NIL) THEN
        BEGIN
        GetFocus(pSavedFocus);
        gPrinting := False;
        gDrawingPictScrap := False;
        gDrawingPictScrapView := NIL;
        theObjectList := GetObjectList(ObjClassIdHandle(theObject)^^);
        IF theObjectList <> NIL THEN
            BEGIN
            index := theObjectList.GetEqualItemNo(theObject);
            theObjectList.Delete(theObject);
            IF (fWindowList <> NIL) & (fWindowList.GetSize > 0) THEN
                BEGIN
                ForAllWindowsDo(CheckWindow);
                END;
            END;
        SetFocus(pSavedFocus);
        END;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.IRes(itsDocument: TDocument;
                              itsSuperView: TView;
                              VAR itsParams: Ptr); OVERRIDE;

    BEGIN
    INHERITED IRes(itsDocument, itsSuperView, itsParams);

{$Push} {$H-}
    SetPt(fResizeLimits.topLeft, 151, 142);
{$Pop}
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.Initialize; OVERRIDE;

    BEGIN
    INHERITED Initialize;
    fClassListView := NIL;
    fObjListView := NIL;
    fObjectView := NIL;
    END;

PROCEDURE TInspectWindow.IInspectWindow;

    VAR
        aWMgrWindow:        WindowPtr;
        canResize:            BOOLEAN;
        canClose:            BOOLEAN;
        fi:                 FailInfo;
        aClassListView:     TClassListView;
        anObjListView:        TObjListView;
        anObjectView:        TObjectView;
        aScroller:            TScroller;
        itsLocation:        VPoint;
        itsSize:            VPoint;
        screenRect:         Rect;
        aVPt:                VPoint;

    PROCEDURE HandleFailure(error: INTEGER;
                            message: LONGINT);

        BEGIN
        {the wmgrWindow is known to exist}
  {Since aWindow didn't get created, the wmgrWindow won't be
   freed unless we do it here.}

        aWMgrWindow := FreeIfWMgrWindow(aWMgrWindow, TRUE);

        END;

    BEGIN

    aWMgrWindow := NIL;
    aWMgrWindow := gApplication.GetRsrcWindow(NIL, kInspectorWindowType, canResize, canClose);
    {GetRsrcWindow signals Failure}

    CatchFailures(fi, HandleFailure);
    IWindow(pInspector, aWMgrWindow, canResize, canClose, TRUE);
{$Push} {$H-}
    SetPt(fResizeLimits.topLeft, 151, 142);
{$Pop}

    fClosesDocument := False;
    fFreeOnClosing := TRUE;

    SetVPt(itsLocation, 0, 0);
    SetVPt(itsSize, 65, 12 * 6);
    New(aClassListView);
    aClassListView.IClassListView(SELF, itsLocation, itsSize);
    fClassListView := aClassListView;

    SetVPt(itsLocation, 81, 0);
    SetVPt(itsSize, 200 - 81, 12 * 6);
    New(anObjListView);
    anObjListView.IObjListView(SELF, itsLocation, itsSize);
    fObjListView := anObjListView;

    SetVPt(itsLocation, 0, 12 * 6 + 1);
    SetVPt(itsSize, 200, fWMgrWindow^.portRect.bottom - itsLocation.v);
    New(anObjectView);
    anObjectView.IObjectView(SELF, itsLocation, itsSize);
    fObjectView := anObjectView;

    SetTarget(anObjectView);                            { !!! }

    fSize := gZeroVPt;                                    { Make sure window gets resized }
    WITH fWMgrWindow^.portRect DO
        begin
        SetVPt(aVPt, right - left, bottom - top);
        Resize(aVPt, kDontInvalidate);
        end;

    { Use GetMaxIntersectedDevice to Locate our window. }
    IF GetMaxIntersectedDevice(screenRect) = NIL THEN;
    WITH screenRect DO
        BEGIN
        SetVPt(aVPt, right - fWMgrWindow^.portRect.right, top + fContRgnInset.v);
        Locate(aVPt, kDontInvalidate);

        {Adapt height of window to height of screen}
        SetVPt(aVPt, fWMgrWindow^.portRect.right, Max(252, bottom - 192));
        IF bottom > 342 THEN
            Resize(aVPt, kDontInvalidate);
        END;

    Success(fi);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.CloseByUser; OVERRIDE;

    BEGIN
 {Overridden to prevent closing the Inspector document when the last
  inspector window is closed.}
    Close;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.Draw(area: VRect); OVERRIDE;

    BEGIN
    INHERITED Draw(area);

    {Draw horizontal line separating upper views from lower view}
    PenNormal;
    MoveTo(0, fObjectView.fSuperView.fLocation.v - 1);
    Line(fSize.h, 0);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.Fields(obj: TObject); OVERRIDE;

    BEGIN
    WITH obj DO
        BEGIN
        DoToField(AtStr('TInspectWindow'), NIL, bClass);
        DoToField(AtStr('fClassListView'), @fClassListView, bObject);
        DoToField(AtStr('fObjListView'), @fObjListView, bObject);
        DoToField(AtStr('fObjectView'), @fObjectView, bObject);
        END;
    INHERITED Fields(obj);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.Resize(newSize: VPoint;
                                invalidate: BOOLEAN); OVERRIDE;

    VAR
        aVPt:                VPoint;

    BEGIN
    INHERITED Resize(newSize, invalidate);

 {Resize the upper-right and bottom view to match the window's
  new size.}
    IF fClassListView <> NIL THEN
        BEGIN
        SetVPt(aVPt, BSR(newSize.h, 1) - kSBarSizeMinus1, fSize.v);
        WITH fClassListView.fSuperView DO
            fClassListView.fSuperView.Resize(aVPt, invalidate);
        END;
    IF fObjListView <> NIL THEN
        BEGIN
        SetVPt(aVPt, BSR(newSize.h, 1) + 1, 0);
        fObjListView.fSuperView.Locate(aVPt, invalidate);
        SetVPt(aVPt, newSize.h - fLocation.h - kSBarSizeMinus1, fSize.v);
        WITH fObjListView.fSuperView DO
            fObjListView.fSuperView.Resize(aVPt, invalidate);
        END;
    IF fObjectView <> NIL THEN
        BEGIN
        SetVPt(aVPt, newSize.h - kSBarSizeMinus1, (newSize.v -
                                          fObjectView.fSuperView.fLocation.v) - kSBarSizeMinus1);
        WITH fObjectView.fSuperView DO
            fObjectView.fSuperView.Resize(aVPt, invalidate);
        END;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.InsertClass(itemNo: INTEGER);

    BEGIN
    IF fClassListView <> NIL THEN
        fClassListView.InsertItem(itemNo);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.SetNumberOfClasses(noOfClasses: INTEGER);

    BEGIN
    IF fClassListView <> NIL THEN
        fClassListView.SetNumberOfItems(noOfClasses);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.SetTitleForDoc(newDocTitle: Str255); OVERRIDE;
    VAR
        aTitle: Str255;
        aString: Str255;
    BEGIN
    aString := 'Inspector ';
    ConcatNumber(aString, pInspector.fWindowCount,aTitle);

    SetTitle(aTitle);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.SelectObject(theObject: TObject;
                                      theType: INTEGER);

 {This installs the given object as the selected object of the window,
  making sure that the class list and object list views are in sync.}

    VAR
        objectItemNumber, classItemNumber: INTEGER;
        classId:            ObjClassID;
        anObjectList:        TSortedList;
        anObject:            TObject;

    FUNCTION TestClass(anObjectList: TSortedList): BOOLEAN;

        BEGIN
        classItemNumber := classItemNumber + 1;
        TestClass := anObjectList.fObjClassId = classId;
        END;

    FUNCTION TestObject(anObject: TObject): BOOLEAN;

        BEGIN
        objectItemNumber := objectItemNumber + 1;
        TestObject := anObject = theObject;
        END;

    BEGIN
    IF NOT (ODD(LONGINT(theObject))) THEN                {* check for uninitialized object *}
        BEGIN
        IF theType = bObject THEN
            BEGIN
            {* get the new class *}
            classItemNumber := 0;
            classId := GetClassID(theObject);
            anObjectList := TSortedList(pInspector.fClassesByName.FirstThat(TestClass));
            IF anObjectList <> NIL THEN
                BEGIN
                objectItemNumber := 0;
                anObject := anObjectList.FirstThat(TestObject);
                IF anObject <> NIL THEN
                    BEGIN
                    { turn off the old class and select the new class }
                    fClassListView.ChangeSelection(classItemNumber, TRUE);
                    fClassListView.RevealItem(classItemNumber);
                    { turn off the old item and select the new item }
                    fObjListView.ChangeSelection(objectItemNumber, TRUE);
                    END;
                END
{$IFC qDebugTheDebugger}
            ELSE
                BEGIN
                ProgramBreak('TInspectWindow.SelectObject: Unable to find class');
                END
{$ENDC}
            ;
            END

        ELSE IF theType <> 0 THEN
            fObjectView.InstallObject(theObject, theType);
        END;
    END;

{ Based on work by Kurt Shmucker Copyright 1986 by Productivity Products International, Inc.
    Used by permission. }

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.Initialize; OVERRIDE;

    BEGIN
    INHERITED Initialize;

    fCurrentSelection := 0;
    fItemHeight := 0;                                    {!!! Better defaults? }
    fLineAscent := 0;
    fNumberOfItems := 0;
    fTextStyle := pInspectorStyle;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TListView.IRes(itsDocument: TDocument;
                         itsSuperView: TView;
                         VAR itsParams: Ptr); OVERRIDE;

    BEGIN
    INHERITED IRes(itsDocument, itsSuperView, itsParams);

    SetStyle(pInspectorStyle);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.IListView(itsDocument: TDocument;
                              itsSuperView: TView;
                              itsLocation: VPoint;
                              itsSize: VPoint;
                              itsTextStyle: TextStyle;
                              itsNumberOfItems: INTEGER;
                              itsHSizeDet: SizeDeterminer);

    BEGIN
    IView(itsDocument, itsSuperView, itsLocation, itsSize, itsHSizeDet, sizeVariable);
    fNumberOfItems := itsNumberOfItems;
    SetStyle(itsTextStyle);

    AddAdorner(gSelectionAdorner, kViewAdornPriority, FALSE);                        { wants DoHighlightSelection }
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.CalcMinSize(VAR minSize: VPoint); OVERRIDE;

    BEGIN
    INHERITED CalcMinSize(minSize);
    { Set the amount of room needed for that many items }
    minSize.v := IntMultiply(fNumberOfItems, fItemHeight);

    IF fNumberOfItems <> 0 THEN
        minSize.h := Max(600, fSuperView.fSize.h)
    ELSE
        minSize.h := 0;
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.ChangeSelection(index: INTEGER;
                                    highlight: BOOLEAN);

    BEGIN
    IF highlight & IsDrawable THEN
        BEGIN
        DoHighlightSelection(fHLDesired, hlOff);
        fCurrentSelection := index;
        DoHighlightSelection(hlOff, fHLDesired);
        END
    ELSE
        fCurrentSelection := index;
    SelectItem(index);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.DeleteItem(itemNo: INTEGER);

    VAR
        topRect, bottomRect: VRect;

    BEGIN
    IF fCurrentSelection > 0 THEN
        IF itemNo < fCurrentSelection THEN
            fCurrentSelection := fCurrentSelection - 1
        ELSE IF itemNo = fCurrentSelection THEN
            fCurrentSelection := 0;

    fNumberOfItems := fNumberOfItems - 1;
    AdjustSize;

    { Invalidate from the deleted item to the end }
    ItemToVRect(itemNo, topRect);
    ItemToVRect(fNumberOfItems, bottomRect);
    topRect.bottom := bottomRect.bottom;
    InvalidateVRect(topRect);
    END;

{--------------------------------------------------------------------------------------------------}

{ Dim highlighting of text by gray XORing is not very readable, so dim highlight a text string
by framing it with a gray rectangle.  (Standard highlighting when the window displaying
the view is active is still to invert - black XORing.)    The state transition diagram is:

                                              hlTo

                      |     OFF      |           DIM          |       ON
           -----------|--------------|--------------------|--------------------
               OFF      |     (NA)     |          Frame       |      Invert
           -----------|--------------|--------------------|--------------------
hlFrom           DIM      |     Frame     |          (NA)          |  Frame and Invert
           -----------|--------------|--------------------|--------------------
               ON      |    Invert     |    Invert and Frame  |       (NA)
           -----------|--------------|-----------------------------------------

Since this matrix is (almost) symmetric, we can add together the hlFrom and hlTo parameters
and take one action for each of the three possible sums.  }

PROCEDURE TListView.DoHighlightSelection(fromHL, toHL: HLState); OVERRIDE;

    VAR
        itemVRect:            VRect;
        r:                    Rect;

    BEGIN
    IF (fCurrentSelection > 0) THEN
        BEGIN
        { Make r be the rectangle to invert }
        ItemToVRect(fCurrentSelection, itemVRect);
        ViewToQDRect(itemVRect, r);

        { Set the pen pattern and mode properly }
        PenPat(black);
        PenMode(patXor);

        IF IsRectDrawable(r) THEN
            BEGIN
            CASE (fromHL + toHL) OF
                hlOffDim:
                    BEGIN
                    UseSelectionColor;
                    FrameRect(r);
                    END;
                hlOffOn:
                    BEGIN
                    UseSelectionColor;
                    InvertRect(r);
                    END;
                hlDimOn:
                    IF fromHL = hlDim THEN
                        BEGIN
                        UseSelectionColor;
                        FrameRect(r);
                        UseSelectionColor;
                        InvertRect(r);
                        END
                    ELSE
                        BEGIN
                        UseSelectionColor;
                        InvertRect(r);
                        UseSelectionColor;
                        FrameRect(r);
                        END;
            END
            END
        END
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.DoMouseCommand(VAR theMouse: VPoint;
                                   event: TToolboxEvent;
                                   hysteresis: Point); OVERRIDE;

    VAR
        index:                INTEGER;

    BEGIN
    index := VPointToItem(theMouse);
    IF (index > 0) & (index <= fNumberOfItems) THEN
        ChangeSelection(index, TRUE);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.Draw(area: VRect); OVERRIDE;

    VAR
        i, firstItem, lastItem: INTEGER;
        viewArea:            VRect;
        baseVPoint:         VPoint;

    BEGIN
    SetPen;
    viewArea := area;
    WITH viewArea DO
        BEGIN
        {adjust for QuickDraw geometry}
        bottom := bottom - 1;
        right := right - 1;

        firstItem := top DIV fItemHeight + 1;
        lastItem := Min(fNumberOfItems, bottom DIV fItemHeight + 1);
        END;

    SetVPt(baseVPoint, 4, IntMultiply(firstItem - 1, fItemHeight) + fLineAscent);
    FOR i := firstItem TO lastItem DO
        BEGIN
        DrawItem(i, baseVPoint);
        baseVPoint.v := baseVPoint.v + fItemHeight;
        END;

    INHERITED Draw(area);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.DrawItem(itemNumber: INTEGER;
                             basePoint: VPoint);

    BEGIN
    SubClassResponsibility;
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.Fields(obj: TObject); OVERRIDE;

    BEGIN
    WITH obj DO
        BEGIN
        DoToField(AtStr('TListView'), NIL, bClass);
        DoToField(AtStr('fCurrentSelection'), @fCurrentSelection, bInteger);
        DoToField(AtStr('fNumberOfItems'), @fNumberOfItems, bInteger);

        DoToField(AtStr('fTextStyle'), @fTextStyle, bTextStyle);

        DoToField(AtStr('fItemHeight'), @fItemHeight, bInteger);
        DoToField(AtStr('fLineAscent'), @fLineAscent, bInteger);
        END;
    INHERITED Fields(obj);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.InsertItem(itemNo: INTEGER);

    VAR
        topRect, bottomRect: VRect;

    BEGIN
    IF (fCurrentSelection > 0) & (itemNo <= fCurrentSelection) THEN
        fCurrentSelection := fCurrentSelection + 1;

    fNumberOfItems := fNumberOfItems + 1;
    AdjustSize;

    { Invalidate from the inserted item to the end }
    ItemToVRect(itemNo, topRect);
    ItemToVRect(fNumberOfItems, bottomRect);
    topRect.bottom := bottomRect.bottom;
    InvalidateVRect(topRect);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.ItemToVRect(index: INTEGER;
                                VAR itemRect: VRect);

    BEGIN
    GetExtent(itemRect);
    itemRect.top := IntMultiply(index - 1, fItemHeight); { Subtract 1 to get the TOP line }
    itemRect.bottom := itemRect.top + fItemHeight;
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.RevealItem(itemNumber: INTEGER);

    VAR
        howMuch:            VPoint;
        rectToReveal:        VRect;

    BEGIN
    SetVPt(howMuch, 0, fItemHeight);
    ItemToVRect(itemNumber, rectToReveal);
    RevealRect(rectToReveal, howMuch, kRedraw);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.SelectItem(itemNumber: INTEGER);

    BEGIN
    {Can be overridden to do something when an item is selected.}
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.SetNumberOfItems(numberOfItems: INTEGER);

    BEGIN
    IF numberOfItems <> fNumberOfItems THEN
        BEGIN
        fNumberOfItems := numberOfItems;
        AdjustSize;
        END;
    ForceRedraw;
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.SetStyle(itsTextStyle: TextStyle);

    VAR
        aPort:                GrafPort;
        savedPort:            GrafPtr;
        theFontInfo:        FontInfo;

    BEGIN
    fTextStyle := itsTextStyle;

    {Need a temporary port to set up the font, so we can get the font info}
    GetPort(savedPort);
    OpenPort(@aPort);

    SetPen;
    fItemHeight := MAGetFontInfo(theFontInfo);
    WITH theFontInfo DO
        fLineAscent := ascent + (leading DIV 2) - 1;

    SetPort(savedPort);
    ClosePort(@aPort);
    AdjustSize;
    END;                                                { TListView.SetStyle }

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.SetPen;

    VAR
        itsTextStyle:        TextStyle;

    BEGIN
    PenNormal;
    itsTextStyle := fTextStyle;
    SetPortTextStyle(itsTextStyle);
    END;

{--------------------------------------------------------------------------------------------------}

FUNCTION TListView.VPointToItem(thePoint: VPoint): INTEGER;

    BEGIN
    VPointToItem := (thePoint.v DIV fItemHeight) + 1;
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TClassListView.Initialize; OVERRIDE;

    BEGIN
    INHERITED Initialize;

    fInspectWindow := NIL;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TClassListView.IRes(itsDocument: TDocument;
                              itsSuperView: TView;
                              VAR itsParams: Ptr); OVERRIDE;

    VAR
        aVPt:                VPoint;

    BEGIN
    INHERITED IRes(itsDocument, itsSuperView, itsParams);

    SetVPt(aVPt, 0, fItemHeight);
    GetScroller(TRUE).SetScrollParameters(aVPt, False, TRUE);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TClassListView.IClassListView(itsWindow: TInspectWindow;
                                        itsLocation: VPoint;
                                        itsSize: VPoint);

    VAR
        aScroller:            TScroller;
        aVPt:                VPoint;

    BEGIN
    New(aScroller);
    aScroller.IScroller(itsWindow, itsLocation, itsSize, sizeFixed, sizeFixed, gZeroVPt, False,
                        TRUE);

    itsSize.v := 0;                                     { start off with no items }
    IListView(pInspector, aScroller, gZeroVPt, itsSize, pInspectorStyle, 0, sizeFixed);

    SetVPt(aVPt, 0, fItemHeight);
    aScroller.SetScrollParameters(aVPt, False, TRUE);

    fInspectWindow := itsWindow;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TClassListView.DrawItem(itemNumber: INTEGER;
                                  basePoint: VPoint); OVERRIDE;

    VAR
        className:            MAName;
        aStringPtr:         StringPtr;
        p:                    Point;

    BEGIN
    GetClassNameFromID(TSortedList(pInspector.fClassesByName.At(itemNumber)).fObjClassId,
                       className);
    p := ViewToQDPt(basePoint);
    MoveTo(p.h, p.v);
    aStringPtr := StringPtr(@className);
    DrawString(aStringPtr^);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TClassListView.SelectItem(itemNumber: INTEGER); OVERRIDE;

    VAR
        theObjectList:        TSortedList;

    BEGIN
    IF itemNumber > 0 THEN
        BEGIN
        theObjectList := TSortedList(pInspector.fClassesByName.At(itemNumber));
        IF (fInspectWindow.fObjListView <> NIL) THEN
            fInspectWindow.fObjListView.InstallObjectList(theObjectList)
        ELSE
            fInspectWindow.fObjListView.ChangeSelection(0, TRUE);
        END;

    INHERITED SelectItem(itemNumber);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TClassListView.Fields(obj: TObject); OVERRIDE;

    BEGIN
    WITH obj DO
        BEGIN
        DoToField(AtStr('TClassListView'), NIL, bClass);
        DoToField(AtStr('fInspectWindow'), @fInspectWindow, bObject);
        END;
    INHERITED Fields(obj);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TObjListView.Initialize; OVERRIDE;

    BEGIN
    INHERITED Initialize;

    fInspectWindow := NIL;
    fObjectList := NIL;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjListView.IRes(itsDocument: TDocument;
                            itsSuperView: TView;
                            VAR itsParams: Ptr); OVERRIDE;
    VAR
        aVPt:                VPoint;

    BEGIN
    INHERITED IRes(itsDocument, itsSuperView, itsParams);

    SetVPt(aVPt, 0, fItemHeight);
    GetScroller(TRUE).SetScrollParameters(aVPt, False, TRUE);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjListView.IObjListView(itsWindow: TInspectWindow;
                                    itsLocation: VPoint;
                                    itsSize: VPoint);

    VAR
        aScroller:            TScroller;
        aVPt:                VPoint;

    BEGIN
    New(aScroller);
    aScroller.IScroller(itsWindow, itsLocation, itsSize, sizeRelSuperView, sizeFixed, gZeroVPt,
                        kWantHScrollBar, kWantVScrollBar);
    itsSize.v := 0;                                     { Start off with no items }
    IListView(pInspector, aScroller, gZeroVPt, itsSize, pInspectorStyle, 0, sizeRelSuperView);
    SetVPt(aVPt, 0, fItemHeight);
    aScroller.SetScrollParameters(aVPt, False, TRUE);
    fInspectWindow := itsWindow;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjListView.DrawItem(itemNumber: INTEGER;
                                basePoint: VPoint); OVERRIDE;

    VAR
        s1:                 Str255;
        aString:            Str255;
        theObject:            TObject;
        p:                    Point;

    BEGIN
    theObject := fObjectList.At(itemNumber);
    PointerToHex(ORD4(theObject), s1, 6);
    aString := '';
    theObject.GetInspectorName(aString);
    aString := CONCAT(s1, ': ', aString);
    p := ViewToQDPt(basePoint);
    MoveTo(p.h, p.v);
    DrawString(aString);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjListView.SelectItem(itemNumber: INTEGER); OVERRIDE;

    BEGIN
 {Assume that we've gotten here only if the field is one that can
  be selected.}
    IF itemNumber > 0 THEN
        fInspectWindow.fObjectView.InstallObject(fObjectList.At(itemNumber), bObject);

    INHERITED SelectItem(itemNumber);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjListView.Fields(obj: TObject); OVERRIDE;

    BEGIN
    WITH obj DO
        BEGIN
        DoToField(AtStr('TObjListView'), NIL, bClass);
        DoToField(AtStr('fInspectWindow'), @fInspectWindow, bObject);
        DoToField(AtStr('fObjectList'), @fObjectList, bObject);
        END;
    INHERITED Fields(obj);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjListView.InstallObjectList(theObjectList: TSortedList);

    BEGIN
    ChangeSelection(0, TRUE);
    IF fObjectList <> theObjectList THEN
        BEGIN
        fObjectList := theObjectList;
        SetNumberOfItems(theObjectList.GetSize);
        RevealTop(kDontRedraw);
        ForceRedraw;
        END;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.Initialize; OVERRIDE;

    BEGIN
    INHERITED Initialize;
    fFieldsProc := NIL;
    fFieldsStaticLink := NIL;
    fInspectWindow := NIL;
    fLockState := False;
    fObject := NIL;
    fType := bObject;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.IRes(itsDocument: TDocument;
                           itsSuperView: TView;
                           VAR itsParams: Ptr); OVERRIDE;
    VAR
        aVPt:                VPoint;


    BEGIN
    INHERITED IRes(itsDocument, itsSuperView, itsParams);

    SetVPt(aVPt, kSBarSize, fItemHeight);
    GetScroller(TRUE).SetScrollParameters(aVPt, TRUE, TRUE);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.IObjectView(itsWindow: TInspectWindow;
                                  itsLocation: VPoint;
                                  itsSize: VPoint);

    VAR
        aScroller:            TScroller;
        aVPt:                VPoint;

    BEGIN
    New(aScroller);
    aScroller.IScroller(itsWindow, itsLocation, itsSize, sizeRelSuperView, sizeRelSuperView, gZeroVPt, TRUE, TRUE);
    aScroller.fSBarOffsets.bottom := - kSBarSizeMinus1;

    itsSize.v := 0;                                     { start off with no items }
    IListView(pInspector, aScroller, gZeroVPt, itsSize, pInspectorStyle, 0, sizeVariable);
    SetVPt(aVPt, kSBarSize, fItemHeight);
    aScroller.SetScrollParameters(aVPt, TRUE, TRUE);
    fInspectWindow := itsWindow;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.InspectControlHandle(PROCEDURE
                                           InspectField(fieldName: StringPtr;
                                                        fieldAddr: Ptr;
                                                        fieldType: INTEGER));

    TYPE
 {This is an alias for the Control Manager ControlRecord.  The only
  difference is that this is an unpacked record and contrlVis and
  contrlHilite are combined in the contrlVisandHilite field.
  We must have an unpacked record to pass addresses of its fields.}
        UControlHandle        = ^UControlPtr;
        UControlPtr         = ^UnpackedControl;
        UnpackedControl     = RECORD
            nextControl:        ControlHandle;
            contrlOwner:        WindowPtr;
            contrlRect:         Rect;
            contrlVisandHilite: INTEGER;
            contrlValue:        INTEGER;
            contrlMin:            INTEGER;
            contrlMax:            INTEGER;
            contrlDefProc:        Handle;
            contrlData:         Handle;
            contrlAction:        ProcPtr;
            contrlrfCon:        LONGINT;
            contrlTitle:        Str255;
            END;

    VAR
        theControl:     UControlHandle;
        savedState:     SignedByte;

    BEGIN
    theControl := UControlHandle(fObject);
    savedState := LockHandleHigh(Handle(theControl));
    WITH theControl^^ DO
        BEGIN
        InspectField(AtStr('nextControl'), @nextControl, bControlHandle);
        InspectField(AtStr('contrlOwner'), @contrlOwner, bWindowPtr);
        InspectField(AtStr('contrlRect'), @contrlRect, bRect);
        InspectField(AtStr('contrlVis'), @contrlVisandHilite, bHighByte);
        InspectField(AtStr('contrlHilite'), @contrlVisandHilite, bLowByte);
        InspectField(AtStr('contrlValue'), @contrlValue, bInteger);
        InspectField(AtStr('contrlMin'), @contrlMin, bInteger);
        InspectField(AtStr('contrlMax'), @contrlMax, bInteger);
        InspectField(AtStr('contrlDefProc'), @contrlDefProc, bHandle);
        InspectField(AtStr('contrlData'), @contrlData, bHandle);
        InspectField(AtStr('contrlrfCon'), @contrlrfCon, bHexLongInt);
        InspectField(AtStr('contrlTitle'), @contrlTitle, bString);
        END;
    HSetState(Handle(theControl), savedState);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.InspectGrafPtr(PROCEDURE InspectField(fieldName: StringPtr;
                                                            fieldAddr: Ptr;
                                                            fieldType: INTEGER));

    VAR
        thePort:            GrafPtr;
        theCPort:            CGrafPtr;

    BEGIN
    thePort := GrafPtr(fObject);
    theCPort := CGrafPtr(fObject);
    IF (qNeedsColorQD | gConfiguration.hasColorQD) & (BAND(theCPort^.portVersion, $C000) =
       $0000C000) THEN                                   { 2 hi bits. IM V pp. 49-50 }
        WITH theCPort^ DO
            BEGIN
            InspectField(AtStr('device'), @device, bInteger);
            InspectField(AtStr('portPixMap'), @portPixMap, bHandle);
            InspectField(AtStr('portVersion'), @portVersion, bHexInteger);
            InspectField(AtStr('grafVars'), @grafVars, bHandle);
            InspectField(AtStr('chExtra'), @chExtra, bInteger);
            InspectField(AtStr('pnLocHFrac'), @pnLocHFrac, bHexInteger);
            InspectField(AtStr('portRect'), @portRect, bRect);
            InspectField(AtStr('visRgn'), @visRgn, bRgnHandle);
            InspectField(AtStr('clipRgn'), @clipRgn, bRgnHandle);
            InspectField(AtStr('bkPixPat'), @bkPixPat, bHandle);
            InspectField(AtStr('rgbFgColor'), @rgbFgColor, bRGBColor);
            InspectField(AtStr('rgbBkColor'), @rgbBkColor, bRGBColor);
            InspectField(AtStr('pnLoc'), @pnLoc, bPoint);
            InspectField(AtStr('pnSize'), @pnSize, bPoint);
            InspectField(AtStr('pnMode'), @pnMode, bInteger);
            InspectField(AtStr('pnPixPat'), @pnPixPat, bHandle);
            InspectField(AtStr('fillPixPat'), @fillPixPat, bHandle);
            END
    ELSE
        WITH thePort^ DO
            BEGIN
            InspectField(AtStr('device'), @device, bInteger);
            InspectField(AtStr('portBits.baseAddr'), @portBits.baseAddr, bPointer);
            InspectField(AtStr('portBits.rowBytes'), @portBits.rowBytes, bInteger);
            InspectField(AtStr('portBits.bounds'), @portBits.bounds, bRect);
            InspectField(AtStr('portRect'), @portRect, bRect);
            InspectField(AtStr('visRgn'), @visRgn, bRgnHandle);
            InspectField(AtStr('clipRgn'), @clipRgn, bRgnHandle);
            InspectField(AtStr('bkPat'), @bkPat, bPattern);
            InspectField(AtStr('fillPat'), @fillPat, bPattern);
            InspectField(AtStr('pnLoc'), @pnLoc, bPoint);
            InspectField(AtStr('pnSize'), @pnSize, bPoint);
            InspectField(AtStr('pnMode'), @pnMode, bInteger);
            InspectField(AtStr('pnPat'), @pnPat, bPattern);
            END;
    {The rest of the fields are common to both GrafPorts and CGrafPorts}
    WITH thePort^ DO
        BEGIN
        InspectField(AtStr('pnVis'), @pnVis, bInteger);
        InspectField(AtStr('txFont'), @txFont, bInteger);
        InspectField(AtStr('txFace'), @txFace, bHexInteger);
        InspectField(AtStr('txMode'), @txMode, bInteger);
        InspectField(AtStr('txSize'), @txSize, bInteger);
        InspectField(AtStr('spExtra'), @spExtra, bFixed);
        InspectField(AtStr('fgColor'), @fgColor, bLongInt);
        InspectField(AtStr('bkColor'), @bkColor, bLongInt);
        InspectField(AtStr('colrBit'), @colrBit, bInteger);
        InspectField(AtStr('patStretch'), @patStretch, bInteger);
        InspectField(AtStr('picSave'), @picSave, bHandle);
        InspectField(AtStr('rgnSave'), @rgnSave, bHandle);
        InspectField(AtStr('polySave'), @polySave, bHandle);
        InspectField(AtStr('grafProcs'), @grafProcs, bPointer);
        END;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.InspectRgnHandle(PROCEDURE InspectField(fieldName: StringPtr;
                                                              fieldAddr: Ptr;
                                                              fieldType: INTEGER));

    VAR
        theRgn:         RgnHandle;
        savedState:     SignedByte;

    BEGIN
    theRgn := RgnHandle(fObject);
    savedState := LockHandleHigh(Handle(theRgn));
    WITH theRgn^^ DO
        BEGIN
        InspectField(AtStr('rgnSize'), @rgnSize, bInteger);
        InspectField(AtStr('rgnBBox'), @rgnBBox, bRect);
        END;
    HSetState(Handle(theRgn), savedState);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.InspectHandle(PROCEDURE InspectField(fieldName: StringPtr;
                                                           fieldAddr: Ptr;
                                                           fieldType: INTEGER));

    VAR
        theHandle:            Handle;

    PROCEDURE ShowMemory(startAddress, numBytes: LONGINT);

        VAR
            i:                    INTEGER;
            addr, lineAddr:     LONGINT;
            numeric:            STRING[40];
            ascii:                STRING[16];
            numPos:             INTEGER;
            ascPos:             INTEGER;
            decNumber:            LONGINT;
            chCode:             INTEGER;
            j:                    INTEGER;

{--------------------------------------------------------------------------------------------------}

        PROCEDURE BlankLine;

            CONST
                k8Spaces            = '        ';

            BEGIN
            ascii := CONCAT(k8Spaces, k8Spaces);
            numeric := CONCAT(ascii, ascii, k8Spaces);
            numPos := 0;
            ascPos := 0;
            END;

{--------------------------------------------------------------------------------------------------}

        PROCEDURE PrintLine;

            VAR
                aStr:                Str255;
                tempString:         String8;

            BEGIN
            LIntToHex(lineAddr, tempString, 8);
            aStr := CONCAT('$', tempString, ': ', numeric, '  ', ascii);
            InspectField(AtStr(''), @aStr, bInternalString);

            END;

        BEGIN
        IF ODD(startAddress) THEN
            InspectField(AtStr('Odd Address'), NIL, bTitle)
        ELSE IF numBytes > 0 THEN
            BEGIN
            BlankLine;

            FOR i := 0 TO (numBytes - 1) DIV 2 DO
                BEGIN
                addr := startAddress + i + i;

                IF (i MOD 8) = 0 THEN
                    BEGIN
                    IF i > 0 THEN
                        BEGIN
                        PrintLine;
                        BlankLine;
                        END;
                    lineAddr := addr;                    { save the address for printline to use }
                    END;

                decNumber := IntegerPtr(addr)^;
                FOR j := 4 DOWNTO 1 DO
                    BEGIN
                    numeric[numPos + j] := kHexDigits[BAND(decNumber, 15) + 1];
                    decNumber := BSR(decNumber, 4);
                    END;

                decNumber := IntegerPtr(addr)^;
                FOR j := 2 DOWNTO 1 DO
                    BEGIN
                    chCode := BAND(decNumber, 255);
                    IF (chCode < $20) | (chCode > $D8) | (chCode = $7F) THEN { control, unassigned,
                           or DEL }
                        chCode := ord('•');
                    ascii[ascPos + j] := CHR(chCode);
                    decNumber := BSR(decNumber, 8);
                    END;

                numPos := numPos + 5;
                ascPos := ascPos + 2;
                END;

            PrintLine;
            END;
        END;

    BEGIN
    theHandle := Handle(fObject);
    ShowMemory(longint(theHandle^), GetHandleSize(theHandle));
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.InspectTEHandle(PROCEDURE InspectField(fieldName: StringPtr;
                                                             fieldAddr: Ptr;
                                                             fieldType: INTEGER));

    VAR
        hTE:            TEHandle;
        savedState:     SignedByte;

    BEGIN
    hTE := TEHandle(fObject);
    savedState := LockHandleHigh(Handle(hTE));
    WITH hTE^^ DO
        BEGIN
        InspectField(AtStr('destRect'), @destRect, bRect);
        InspectField(AtStr('viewRect'), @viewRect, bRect);
        InspectField(AtStr('selRect'), @selRect, bRect);
        InspectField(AtStr('lineHeight'), @lineHeight, bInteger);
        InspectField(AtStr('fontAscent'), @fontAscent, bInteger);
        InspectField(AtStr('selPoint'), @selPoint, bPoint);
        InspectField(AtStr('selStart'), @selStart, bInteger);
        InspectField(AtStr('selEnd'), @selEnd, bInteger);
        InspectField(AtStr('active'), @active, bInteger);
        InspectField(AtStr('wordBreak'), @wordBreak, bPointer);
        InspectField(AtStr('clikLoop'), @clikLoop, bPointer);
        InspectField(AtStr('clickTime'), @clickTime, bLongInt);
        InspectField(AtStr('clickLoc'), @clickLoc, bInteger);
        InspectField(AtStr('caretTime'), @caretTime, bLongInt);
        InspectField(AtStr('caretState'), @caretState, bInteger);
        InspectField(AtStr('just'), @just, bInteger);
        InspectField(AtStr('teLength'), @teLength, bInteger);
        InspectField(AtStr('hText'), @hText, bHandle);
        InspectField(AtStr('recalBack'), @recalBack, bInteger);
        InspectField(AtStr('recalLines'), @recalLines, bInteger);
        InspectField(AtStr('clikStuff'), @clikStuff, bHexInteger);
        InspectField(AtStr('crOnly'), @crOnly, bInteger);
  {If txSize is -1 then the txFont and txFace fields are replaced
   by a handle to a style record.  See Inside Mac Vol. 5.}
        IF txSize = - 1 THEN
            InspectField(AtStr('txFont,txFace'), @txFont, bHandle)
        ELSE
            BEGIN
            InspectField(AtStr('txFont'), @txFont, bInteger);
            InspectField(AtStr('txFace'), @txFace, bStyle);
            END;
        InspectField(AtStr('txMode'), @txMode, bInteger);
        InspectField(AtStr('txSize'), @txSize, bInteger);
        InspectField(AtStr('inPort'), @inPort, bGrafPtr);
        InspectField(AtStr('highHook'), @highHook, bPointer);
        InspectField(AtStr('caretHook'), @caretHook, bPointer);
        InspectField(AtStr('nLines'), @nLines, bInteger);
        END;
    HSetState(Handle(hTE), savedState);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.InspectWindowPtr(PROCEDURE InspectField(fieldName: StringPtr;
                                                              fieldAddr: Ptr;
                                                              fieldType: INTEGER));

    VAR
        theWindow:            WindowPeek;

    BEGIN
    InspectGrafPtr(InspectField);
    theWindow := WindowPeek(fObject);
    WITH theWindow^ DO
        BEGIN
        InspectField(AtStr('windowKind'), @windowKind, bInteger);
        InspectField(AtStr('visible'), @visible, bBoolean);
        InspectField(AtStr('hilited'), @hilited, bBoolean);
        InspectField(AtStr('goAwayFlag'), @goAwayFlag, bBoolean);
        InspectField(AtStr('spareFlag'), @spareFlag, bBoolean);
        InspectField(AtStr('strucRgn'), @strucRgn, bRgnHandle);
        InspectField(AtStr('contRgn'), @contRgn, bRgnHandle);
        InspectField(AtStr('updateRgn'), @updateRgn, bRgnHandle);
        InspectField(AtStr('windowDefProc'), @windowDefProc, bHandle);
        InspectField(AtStr('dataHandle'), @dataHandle, bHandle);
        InspectField(AtStr('titleHandle'), @titleHandle, bHandle);
        InspectField(AtStr('titleWidth'), @titleWidth, bInteger);
        InspectField(AtStr('controlList'), @controlList, bControlHandle);
        InspectField(AtStr('nextWindow'), @nextWindow, bWindowPtr);
        InspectField(AtStr('windowPic'), @windowPic, bHandle);
        InspectField(AtStr('refCon'), @refCon, bHexLongInt);
        END;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.ChangeSelection(index: INTEGER;
                                      highlight: BOOLEAN); OVERRIDE;

    BEGIN
    SelectField(index, fInspectWindow);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.SelectField(index: INTEGER;
                                  inspectWindow: TInspectWindow);

    VAR
        fieldNo:            INTEGER;

    FUNCTION TestField(fieldName: StringPtr;
                       fieldAddr: Ptr;
                       fieldType: INTEGER): BOOLEAN;

        VAR
            count:                INTEGER;

        PROCEDURE TestSubField(theLabel: StringPtr;
                               theString: StringPtr;
                               theData: Ptr;
                               theType: INTEGER);

            BEGIN
            IF fieldNo = index THEN
                BEGIN
                CASE theType OF
                    bObject:
                        IF IsObject(TObjectPtrPtr(theData)^) THEN
                            inspectWindow.SelectObject(TObjectPtrPtr(theData)^, theType);
                    bGrafPtr, bWindowPtr, bTEHandle, bControlHandle, bRgnHandle, bHandle:
                        BEGIN
                        IF Handle(theData)^ <> NIL THEN
                            inspectWindow.SelectObject(TObjectPtrPtr(theData)^, theType);
                        END;
                END;
                END;
            fieldNo := fieldNo + 1;                     { increment so we don't test fieldNo again }
            END;

        BEGIN
        count := 0;
        FieldToCount(count, fieldType);
        IF fieldNo = index THEN
            BEGIN
            CASE fieldType OF
                bObject:
                    IF IsObject(TObjectPtrPtr(fieldAddr)^) THEN
                        inspectWindow.SelectObject(TObjectPtrPtr(fieldAddr)^, fieldType);
                bGrafPtr, bWindowPtr, bTEHandle, bControlHandle, bRgnHandle, bHandle:
                    BEGIN
                    IF Handle(fieldAddr)^ <> NIL THEN
                        inspectWindow.SelectObject(TObjectPtrPtr(fieldAddr)^, fieldType);
                    END;
            END;
            TestField := TRUE;
            END
        ELSE IF (fieldNo + count) >= index THEN         { Have we chosen subfield of compound type?
                                                         }
            BEGIN
            FieldToString(fieldName, fieldAddr, fieldType, TestSubField);
            TestField := TRUE;
            END
        ELSE
            BEGIN
            TestField := False;
            fieldNo := fieldNo + count + 1;
            END;
        END;

    BEGIN
    IF (index > 0) & (index <= fNumberOfItems) THEN
        BEGIN
        fieldNo := 2;                                    { Skip title line }
        LockObject;
        FirstFieldThat(TestField);
        UnlockObject;
        END;
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TObjectView.DoMouseCommand(VAR theMouse: VPoint;
                                     event: TToolboxEvent;
                                     hysteresis: Point); OVERRIDE;

    VAR
        index:                INTEGER;
        newInspectWindow:    TInspectWindow;
        wasAddNewObjectsToInspector: BOOLEAN;

    BEGIN
    IF event.fOptionKey THEN
        BEGIN
        index := VPointToItem(theMouse);
        IF (index > 0) & (index <= fNumberOfItems) THEN
            BEGIN
{$IFC NOT qDebugTheDebugger}
            wasAddNewObjectsToInspector := AddNewObjectsToInspector(False);
{$ENDC}
            newInspectWindow := pInspector.MakeWindow;
{$IFC NOT qDebugTheDebugger}
            wasAddNewObjectsToInspector := AddNewObjectsToInspector(wasAddNewObjectsToInspector);
{$ENDC}

            SelectField(index, newInspectWindow);
            newInspectWindow.Open;
            END;
        END
    ELSE
        INHERITED DoMouseCommand(theMouse, event, hysteresis);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TObjectView.Draw(area: VRect); OVERRIDE;

    VAR
        fieldNo, firstField, lastField: INTEGER;
        viewArea:            VRect;
        baseVPoint:         VPoint;
        basePoint:            Point;
        aString:            Str255;

    PROCEDURE FitString(VAR theString: Str255;
                        maxWidth: INTEGER);
    { Truncates theString to fit in maxWidth pixels }

        VAR
            currWidth:            INTEGER;
            noOfChars:            INTEGER;

        BEGIN
        IF StringWidth(theString) > maxWidth THEN
            BEGIN
            currWidth := CharWidth('…');
            noOfChars := 0;
            REPEAT
                noOfChars := noOfChars + 1;
                currWidth := currWidth + CharWidth(theString[noOfChars]);
            UNTIL currWidth > maxWidth;

{$Push} {$R-}
            theString[0] := CHR(noOfChars);             { Set length of theString }
{$Pop}
            theString[noOfChars] := '…';
            END;
        END;

    PROCEDURE GetTitle(VAR aString: Str255);

        VAR
            typeName:            Str255;
            aStringPtr:         MANamePtr;

        BEGIN
        CASE fType OF
            bObject:
                BEGIN
                aStringPtr := MANamePtr(@typeName);
                fObject.GetClassName(aStringPtr^);
                END;
            bGrafPtr:
                typeName := 'GrafPtr:';
            bWindowPtr:
                typeName := 'WindowPtr:';
            bControlHandle:
                typeName := 'ControlHandle:';
            bRgnHandle:
                typeName := 'RgnHandle:';
            bTEHandle:
                typeName := 'TEHandle:';
            bHandle:
                typeName := 'Handle:';
        END;
        PointerToHex(ORD4(fObject), aString, 6);
        aString := CONCAT(typeName, '  ', aString);
        IF fType = bObject THEN
            BEGIN
            typeName := '';
            fObject.GetInspectorName(typeName);
            aString := CONCAT(aString, '  ', typeName);
            END;
        END;

    FUNCTION DrawField(fieldName: StringPtr;
                       fieldAddr: Ptr;
                       fieldType: INTEGER): BOOLEAN;

        VAR
            count:                INTEGER;

        PROCEDURE OutputType(theLabel: StringPtr;
                             theString: StringPtr;
                             theData: Ptr;
                             theType: INTEGER);

            VAR
                s1:                 Str255;
                aString:            Str255;
                aStringPtr:         MANamePtr;
                theObject:            TObject;

            BEGIN
            IF (fieldNo >= firstField) & (fieldNo <= lastField) THEN
                BEGIN
                IF theLabel <> NIL THEN
                    BEGIN
                    aString := CONCAT('   ', theLabel^, ': ');
                    FitString(aString, Max(94, BSR(fSuperView.fSize.h, 1)));
                    MoveTo(4, basePoint.v);
                    DrawString(aString);
                    TextFace([]);
                    END;

                CASE theType OF
                    bObject, bGrafPtr, bWindowPtr, bControlHandle, bRgnHandle, bTEHandle, bHandle:
                        IF Handle(theData)^ <> NIL THEN
                            TextFace([bold]);
                    OTHERWISE;
                END;

                MoveTo(Max(100, BSR(fSuperView.fSize.h, 1) + 4), basePoint.v);

                IF (theType = bObject) & IsObject(TObjectPtrPtr(theData)^) THEN
                    BEGIN
                    theObject := TObjectPtrPtr(theData)^;
                    { $xxxxx: ClassName Inspectorname }
                    PointerToHex(ORD4(theObject), aString, 6);

                    aStringPtr := MANamePtr(@s1);
                    theObject.GetClassName(aStringPtr^);
                    aString := CONCAT(aString, ': ', s1);

                    s1 := '';
                    theObject.GetInspectorName(s1);
                    aString := CONCAT(aString, ' ', s1);
                    DrawString(aString);
                    END
                ELSE
                    DrawString(theString^);

                TextFace([]);
                basePoint.v := basePoint.v + fItemHeight;
                END;
            fieldNo := fieldNo + 1;
            END;

        BEGIN
        DrawField := False;
        count := 0;
        FieldToCount(count, fieldType);
        IF (fieldNo + count) >= firstField THEN
            BEGIN
            IF fieldNo > lastField THEN
                BEGIN
                DrawField := TRUE;
                END
            ELSE
                BEGIN
                IF fieldType = bInternalString THEN
                    BEGIN
                    MoveTo(4, basePoint.v);
                    DrawString(StringPtr(fieldAddr)^);
                    TextFace([]);
                    basePoint.v := basePoint.v + fItemHeight;
                    fieldNo := fieldNo + 1;
                    END
                ELSE
                    BEGIN
                    IF fieldType = bClass THEN
                        BEGIN
                        aString := fieldName^;
                        TextFace([underline]);
                        MoveTo(4, basePoint.v);
                        DrawString(aString);
                        TextFace([]);
                        basePoint.v := basePoint.v + fItemHeight;
                        fieldNo := fieldNo + 1;
                        END
                    ELSE
                        FieldToString(fieldName, fieldAddr, fieldType, OutputType);
                    END;
                END;
            END
        ELSE
            fieldNo := fieldNo + count + 1;
        END;

    BEGIN
    IF fObject <> NIL THEN
        BEGIN
        SetPen;
        viewArea := area;
        WITH viewArea DO
            BEGIN
            {adjust for QuickDraw geometry}
            bottom := bottom - 1;
            right := right - 1;

            firstField := top DIV fItemHeight + 1;
            lastField := Min(fNumberOfItems, bottom DIV fItemHeight + 1);
            END;

        SetVPt(baseVPoint, 4, IntMultiply(firstField - 1, fItemHeight) + fLineAscent);
        basePoint := ViewToQDPt(baseVPoint);

        IF firstField = 1 THEN
            BEGIN
            GetTitle(aString);
            MoveTo(basePoint.h, basePoint.v);
            DrawString(aString);
            basePoint.v := basePoint.v + fItemHeight;
            END;

        fieldNo := 2;                                    { Skip title line }
        LockObject;
        FirstFieldThat(DrawField);
        UnlockObject;
        END;

    INHERITED Draw(area);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.DrawItem(itemNumber: INTEGER;
                               basePoint: VPoint); OVERRIDE;

    BEGIN
    { Do nothing - we've already imaged our list. Don't call INHERITED DrawItem because
    you'll get a "SubClassResponsibility" notification. }
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.SuperViewChangedSize(delta: VPoint;
                                           invalidate: BOOLEAN);

    BEGIN
    IF invalidate THEN
        ForceRedraw;
    INHERITED SuperViewChangedSize(delta, invalidate);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.Resize(newSize: VPoint;
                             invalidate: BOOLEAN); OVERRIDE;

    BEGIN
    {$Push}{$H-}
    IF invalidate & NOT EqualVPt(fSize, newSize) THEN
        ForceRedraw;
    {$Pop}
    INHERITED Resize(newSize, invalidate);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.FirstFieldThat(FUNCTION TestField(fieldName: StringPtr;
                                                        fieldAddr: Ptr;
                                                        fieldType: INTEGER): BOOLEAN);

    LABEL 1000;

    VAR
        oldState:            BOOLEAN;
        fi:                 FailInfo;

    PROCEDURE HandleFailure(error: INTEGER;
                            message: LONGINT);

        BEGIN
        IF error = 0 THEN
            GOTO 1000
        ELSE                                            { someone else signalled it, just let it
                                                         propagate. }
            BEGIN
{$IFC qDebug}
            gIntenseDebugging := oldState;
{$EndC}
            END;
        END;

    PROCEDURE TestAField(fieldName: StringPtr;
                         fieldAddr: Ptr;
                         fieldType: INTEGER);

        BEGIN
        IF TestField(fieldName, fieldAddr, fieldType) THEN
            Failure(0, 0);                                { this is kinder to .Fields methods that
                                                         would quiver when a simple exit would yank
                                                         the rug out from under them }
        END;

    BEGIN
{$IFC qDebug}
    oldState := gIntenseDebugging;
    gIntenseDebugging := False;                         { Suppress printing of info from failure
                                                         signals }
{$EndC}

    CatchFailures(fi, HandleFailure);
    CASE fType OF
        bObject:
            BEGIN
            { Setup the pointer and Staticlink for the nested call back.
            My DoToField method will be called and it will call back through them. }
            fFieldsProc := @TestAField;
            fFieldsStaticLink := GetCurStackFramePtr;

            fObject.Fields(SELF);
            END;
        bGrafPtr:
            InspectGrafPtr(TestAField);
        bWindowPtr:
            InspectWindowPtr(TestAField);
        bControlHandle:
            InspectControlHandle(TestAField);
        bRgnHandle:
            InspectRgnHandle(TestAField);
        bTEHandle:
            InspectTEHandle(TestAField);
        bHandle:
            InspectHandle(TestAField);
    END;
    Success(fi);

1000:
{$IFC qDebug}
    gIntenseDebugging := oldState;
{$EndC}

    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.Fields(obj: TObject); OVERRIDE;

    BEGIN
    WITH obj DO
        BEGIN
        DoToField(AtStr('TObjectView'), NIL, bClass);
        DoToField(AtStr('fInspectWindow'), @fInspectWindow, bObject);
        DoToField(AtStr('fObject'), @fObject, bObject);
        DoToField(AtStr('fType'), @fType, bInteger);
        DoToField(AtStr('fLockState'), @fLockState, bBoolean);

        END;
    INHERITED Fields(obj);
    END;

{---------------------------------------------------------------------------}

PROCEDURE CallFieldsProc(fieldName: StringPtr;
                         fieldAddr: Ptr;
                         fieldType: INTEGER;
                         fieldsStaticLink: Ptr;
                         fieldsProc: ProcPtr);
    INLINE $205F, $4E90;
{  MOVE.L  (A7)+,A0
JSR (A0)
}

PROCEDURE TObjectView.DoToField(fieldName: StringPtr;
                                fieldAddr: Ptr;
                                fieldType: INTEGER); OVERRIDE;

    BEGIN
    CallFieldsProc(fieldName, fieldAddr, fieldType, fFieldsStaticLink, fFieldsProc);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.InstallObject(theObject: TObject;
                                    theObjectType: INTEGER);

    VAR
        noOfFields:         INTEGER;

    FUNCTION CountField(fieldName: StringPtr;
                        fieldAddr: Ptr;
                        fieldType: INTEGER): BOOLEAN;

        BEGIN
        CountField := False;
        noOfFields := noOfFields + 1;                    { Include 1 line for title }
        FieldToCount(noOfFields, fieldType);            { Add additional fields for compound types }
        END;

    BEGIN
    fObject := theObject;
    fType := theObjectType;
    noOfFields := 1;                                    { Includes 1 line for title }
    IF theObject <> NIL THEN
        BEGIN
        LockObject;
        FirstFieldThat(CountField);
        UnlockObject;
        END;
    SetNumberOfItems(noOfFields);
    RevealTop(kDontRedraw);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.LockObject;

    BEGIN
    IF fType = bObject THEN
        fLockState := fObject.Lock(TRUE)
    ELSE IF (fType = bHandle) | (fType = bTEHandle) | (fType = bControlHandle) | (fType =
            bRgnHandle) THEN
        BEGIN
        fLockState := IsHandleLocked(fObject);
        IF NOT fLockState THEN
            HLock(Handle(fObject));
        END;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.UnlockObject;

    VAR
        oldState:            BOOLEAN;

    BEGIN
    IF fType = bObject THEN
        oldState := fObject.Lock(fLockState)
    ELSE IF (fType = bHandle) | (fType = bTEHandle) | (fType = bControlHandle) | (fType =
            bRgnHandle) THEN
        IF NOT fLockState THEN
            HUnLock(Handle(fObject));
    END;